R Vorkurs

class: center, middle, inverse, title-slide

# R Vorkurs
## Teil 1
### Martin Arnold & Jens Klenke
### 28.10 - 30.10.2020

---

class: inverse

# Überischt 
 
1. *R* und *RStudio*
1. Grundlagen 
1. Vektoren
1. Matritzen

---
## *R* und *RStudio*

<code>R</code> ist eine freie Programmiersprache für statistische Berechnungen und Grafiken. 
Sie wurde von Statistikern für Anwender mit statistischen Aufgaben entwickelt.

## Was ist RStudio?

*RStudio* ist eine integrierte Entwicklungsumgebung und grafische Benutzeroberfläche für <code>R</code>:

*RStudio* bietet eine Menge an Komfortfunktionen, die das Arbeiten mit <code>R</code> vereinfachen.

`$\Rightarrow$` **Wir arbeiten daher mit RStudio**

**Wichtig: *RStudio* ist nicht gleich <code>R</code>! Ohne eine <code>R</code>-Installation bringt *RStudio* nichts.** 
 
---
## Grundlagen
 
### Grundrechenarten

<code>R</code> kann als einfacher Taschenrechner benutzt werden.

```r
5 + 7
2 - 8
12 * 12
8 / 3
```

```
## [1] 12
## [1] -6
## [1] 144
## [1] 2.666667
```

---
## Grundlagen
### ... und mehr

```r
# "12 hoch 12"
12^2

# Logarithmus von 144 zur Basis 12
log(144, base = 12)

# "e hoch 3"
exp(3)

# "Logarithmus von e hoch 3"
log(exp(3))

# "Sinus von 2 Pi"
sin(2 * pi)
```

```
## [1] 144
## [1] 2
## [1] 20.08554
## [1] 3
## [1] -2.449213e-16
```

---
## Grundlagen
### Wissenschaftliche Notation

<code>R</code> stellt besonders große bzw. besonders kleine Zahlen mit Hilfe der [wissensschaftlichen Notation](https://de.wikipedia.org/wiki/Wissenschaftliche_Notation) dar. Die Zahl -2.449294e-16 aus dem
<code>R</code>-Output ist entsprechend als

`$$-2.449294 \times 10^{-16} = \dfrac{-2.449294}{10.000.000.000.000.000} \approx 0$$`

(Auf den zweiten Blick ist die wissensschaftliche Notation also tatsächlich nutzerfreundlicher.)

---
## Grundlagen
### Variablen

Variablen werden mit dem Zuweisungsoperator `<-` ("Kleinerzeichen" gefolgt von "Minuszeichen") erzeugt bzw. überschrieben.

```r
x <- 13
y <- 24
```

Mit den so erzeugten Variablen können wir natürlich rechnen.

```r
x - y
```

```
## [1] -11
```

---
## Grundlagen
### Achtung!

**Häufiger Fehler:**

Vergessen von `*`, wenn eine Variable mit einem Skalar multipliziert werden soll.

```r
# Richtig:
3 * x 
```

```
## [1] 39
```

```r
# Falsch:
3x
```

**Problem:**

`R` interpretiert `3x` als Variable, jedoch dürfen Variablennamen nicht mit Ziffern beginnen! Wir erhalten eine Fehlermeldung!

---
## Grundlagen
### Kommentare 
 
Auf der vorherigen Folie steht im letzten Codesnippet eine kurze Erklärung angeführt von einem `#`. Dies kennzeichnet einen [Kommentar](https://de.wikipedia.org/wiki/Kommentar_(Programmierung)): 
 
Kommentare werden beim Ausführen des Codes nicht berücksichtigt. Wir nutzen Sie, um unseren Code (für uns und andere) verständlicher zu machen.

---
## Grundlagen
### Datentypen

Neben den Zahlen gibt es in `R` noch weitere Datentypen. Die für uns wichtigsten (Zahlen eingeschlossen) sind:

```r
a <- 5 # numeric (Zahlen)
class(a)
```

```
## [1] "numeric"
```

```r
b <- "R ist toll!" # character (Schriftzeichen) 
class(b)
```

```
## [1] "character"
```

---
## Grundlagen
### Datentypen

```r
d <- TRUE # logical (TRUE / FALSE)
class(d)
```

```
## [1] "logical"
```

**Häufiger Fehler:**

Vergessen von Anführungszeichen bei Schriftzeichen und Kleinschreiben von `TRUE` oder `FALSE`.

---
## Vektoren 
### Erzeugen eines Vektors

Bisher haben wir nur Variablen betrachtet, die einen einzigen Wert enthalten. 
Die große Stärke von `R` sind vektor- und matrixbasierte Funktionen.

Ein Vektor wird gewöhnlich mit der Funktion `c()` (für **c**ombine) erzeugt und besteht aus einem oder mehreren Elementen **eines** Datentyps.

```r
numeric_v <- c(1, 4, 8)

character_v <- c("Pommes", "Falaffel", "Ketchup")

logical_v <- c(TRUE, FALSE, FALSE)

# oder kürzer `T` für `TRUE` und `F` für `FALSE`
logical_v <- c(T, F, F)
```

**Achtung:** `T` und `F`sollten nicht als Varibalen verwendet werden. Lange Version ist weniger fehleranfällig.

---
## Vektoren 
### Erzeugen eines Vektors

Insbesondere für numerische Vektoren gibt es ein paar hilfreiche Shortcuts:
Jede der folgenden Zeilen liefert den selben Output.

```r
## c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
## 1:10
seq(from = 1, to = 10, by = 1)
```

```
##  [1]  1  2  3  4  5  6  7  8  9 10
```

---
## Vektoren 
### Missing Values

Bei echten Daten kommt es häufig vor, dass es zu einigen Beobachtungen keine Daten für manche Variablen gibt.

**Praxisbeispiel**

Angenommen in einer Umfrage wird das Alter, Geschlecht und die Körpergröße erhoben.

Problem: Einer der Teilnehmer hat keine Angabe zur Körpergröße gemacht.

- In `R` kann der fehlende Wert speziell codiert werden: Anstelle von einer `$-99$` oder `$0$` (sieht man oft in echten Datensätzen) wird für den fehlenden Wert ein `NA` eingesetzt.

- Für viele Funktionen kann das Vorgehen bei *Missing Values* festlegt werden (siehe auch Übungsaufgabe 5).

---
## Vektoren 
### Missing Values

Beim Programmieren werden i.d.R. englische Namen verwendet. Meist sind diese kürzer und man vermeidet Probleme aufgrund von Umlauten.

```r
age <- c(25, 28, 29)

sex <- c("m", "f", "m")

height <- c(184, 165, NA) 
```

---
## Vektoren
### Subsetting von Vektoren

Um eine Untermenge der Elemente eines Vektors anzusprechen (auch *Subsetting* genannt), nutzen wir in eckigen Klammern eingeschlossene Indizes.

```r
numeric_v[2]         # Gibt das 2. Element von numeric_v aus
```

```
## [1] 4
```

```r
character_v[c(1, 3)] # Gibt das 1. und 3. Element von character_v aus
```

```
## [1] "Pommes"  "Ketchup"
```

```r
logical_v[1:2]       # Gibt das 1. und 2. Element von logical_v aus
```

```
## [1]  TRUE FALSE
```

---
## Vektoren
### Subsetting von Vektoren

**Häufiger Fehler:** Vergessen von `c()` im 2. Fall. Mehrere Indizes müssen als *Vektor* übergeben werden.

Wir können auch logische Vektoren für das Subsetting nutzen. Diese müssen dieselbe Länge haben wie der Vektor der "gesubsetted" werden soll. Es werden die Elemente herausgezogen, an deren Stellen der logische Vektor den Wert <code>TRUE</code> hat.

```r
x <- c(7, 2, 5, 3, 9)

# Elemente 2 und 5 sollen angesprochen werden
hv <- c(F, T, F, F, T)

x[hv]
```

```
## [1] 2 9
```

Das ist hilfreich, da viele Funktionen einen logischen Vektor zurückgeben (z.B. `is.na()` und logische Operatoren, später mehr dazu).

---
## Vektoren
### Ändern von Elementen

Manchmal müssen Elemente eines Vektors *geändert* werden. Dazu nutzen wir die Subsetting zusammen mit dem Zuweisungsoperator.

Beispiel: ändere das dritte Element des Vektors `x`

```r
x <- c(7, 2, 5, 3, 9)
x[3] <- 49
```

Wenn wir mehrere Elemente ändern wollen:

```r
x[c(1, 5)] <- c(25, 14) 
x[c(2, 4)] <- -1 # Setzte das 2. und das 4. Element gleich -1 
```

Wie sieht der erzeugte Vektor aus?

---
## Vektoren
### Vektorbasierte Funktionen

Wir betrachten nun den Vektor `age`. Dieser enthält das Alter von 5 Studierenden in diesem Kurs.

```r
age <- c(24, 25, 29, 23, 26)
```

Wie können wir das Durchschnittsalter berechnen?

Wir betrachten nun den Vektor `age`. Dieser enthält das Alter von 5 Studierenden in diesem Kurs.

```r
age <- c(24, 25, 29, 23, 26)
```

Wie können wir das Durchschnittsalter berechnen?

---
## Vektoren
### Vektorbasierte Funktionen 
 
**Antwort:**

```r
age_sum <- age[1] + age[2] + age[3] + age[4] + age[5]
age_sum / 5
```

```
## [1] 25.4
```

Dieses Vorgehen ist für kleine Vektoren noch machbar aber umständlich. Für große Vektoren ist das quasi unmöglich!

---
## Vektoren
### Vektorbasierte Funktionen 
 
Bessere Alternative: *Vordefinierte Funktionen*

```r
# Mittelwert berechnen
age_sum <- sum(age)
age_sum / length(age)
```

```
## [1] 25.4
```

Oder noch einfacher:

```r
mean(age)
```

```
## [1] 25.4
```

---
## Vektoren
### I Need Help
Damit haben wir schon einige `R`-Funktionen kennengelernt. Oft ist unklar, wie diese Funktionen funktionieren.

`$\Rightarrow$` `R`-Hilfe nutzen:

Angenommen wir sind nicht sicher, was `mean()` genau berechnet.

```r
?mean
```

Die `R`-Hilfe ist insbesondere für Anfänger manchmal schwer zu verstehen...

Nicht verzweifeln, sondern einfach ein bisschen rumprobieren oder eine Suchmaschine bemühen!

**Zwei extrem wichtige Fähigkeiten beim Programmieren, die gleich schon mal geübt werden können**

---
## Vektoren
### Vektorbasierte Funktionen --- Eine kleine Übersicht

```r
x <- c(5, 2, 1055, 101:200)

length(x)       # Länge von x

sum(x)          # Summe der Elemente von x

mean(x)         # Arithmetisches Mittel der Elemente von x

min(x)          # kleinstes Element

max(x)          # größtes Element

which.min(x)    # Index des kleinsten Elements

which.max(x)    # Index des größsten Elements

prod(x)         # Produkt aller Elemente

seq_along(x)    # Vektor mit Indizes der Elemente von x
```

---
## Vektoren
### Übungsaufgaben zu Vektoren

1. Erzeugen Sie einen Vektor `numbers` mit den Elementen `$$\{4 , 6, -3, 2.5, 18, \pi, 85\}$$`

*Hinweis:* Die Zahl `$\pi$` ist in `R` bereits bereits als `pi` vordefiniert.

2. Berechnen Sie das arithmetische und das harmonische Mittel von `numbers`.

*Hinweis:* Für einen numerischen Vektor `$X$` der länge `$n$` ist das arithmetische Mittel ist `$\overline{X} = \frac{1}{n} \sum_{i=1}^n X_i$` und das harmonische Mittel `$\overline{X}_{harm} = \frac{n}{\sum_{i=1}^n 1/X_i}$`.

3. Sie kommen zu dem Schluss, dass die höchste und die niedrigste Zahl zu verzerrten Ergebnissen führen und entscheiden darum, diese Werte zu ignorieren. Ersetzen Sie beide Werte durch `NA` und berechnen Sie die Mittelwerte aus Aufgabe 2 erneut.

---
# Vektoren
## Übungsaufgaben zu Vektoren

<ol start="4">
 <li>Nutzen Sie die Funktion <code>seq()</code> um die Folge `$\begin{pmatrix} 0, 0.5, 1, 1.5, \ldots, 99, 99.5, 100 \end{pmatrix}$` zu erzeugen. Wie viele Elemente besitzt dieser Vektor? Überprüfen Sie Ihre Vermutung mit <code>length()</code></li>
 <li>Erzeugen Sie einen neuen Vektor <code>characters</code> mit den Elementen `$\begin{pmatrix} a & a & a & b & b & b & b & c & c \\ \end{pmatrix}$`. Finden Sie heraus, wie die Funktion <code>rep()</code> funktioniert und nutzen Sie diese.</li>
 <li>Überschreiben Sie nun den Vektor <code>characters</code> mit `$\begin{pmatrix} x & y & z & x & y & z & x & y & z \\ \end{pmatrix}$`. Nutzen Sie wieder die Funktion <code>rep()</code>.</li>
 <li>Ersetzen Sie nun alle Einträge mit dem Inhalt <code>"z"</code> durch ein <code>"v"</code>.</li>
</ol>

---
## Vektoren
### Übungsaufgaben zu Vektoren 
<ol start="8">
 <li> Kopieren Sie folgenden Code in Ihr <code>R</code>-Skript und berechen Sie $a + b$, $a + x$, $a + y$ und $a + z$. Finden Sie heraus, wie <code>R</code> jeweils vorgeht.</li>
</ol>

```r
a <- c(2, 5, 7, 5, 12, 6)
b <- c(1, 2, 3, 4, 5, 6)
x <- c(1:2)
y <- 3
z <- c(1, 2, 3, 4)
```

<ol start="9">
 <li>Erzeugen Sie einen Vektor mit den Elementen $\begin{pmatrix} 1 & 2 & 3 & a & b \\ \end{pmatrix}$ (Also eine Mischung aus numeric und character). Was passiert? Schreiben Sie einen Kommentar.</li>
</ol>

---
## Matrizen
### Matrizen erzeugen

Wir können mehrere Vektoren des gleichen Datentyps und gleicher Länge zu einer Matrix zusammenfassen.

```r
x <- 1:3
y <- 4:6

xy <- cbind(x, y)
xy
```

```
##      x y
## [1,] 1 4
## [2,] 2 5
## [3,] 3 6
```

---
## Matrizen
### Matrizen erzeugen

Außerdem können wir auch einen einzelnen Vektor in Matrixform bringen.

```r
matrix(1:6, ncol = 2)
```

```
##      [,1] [,2]
## [1,]    1    4
## [2,]    2    5
## [3,]    3    6
```

---
## Matrizen
### Matrixsubsetting

Um ein Element einer Matrix anzusprechen, müssen wir **zwei** Indizes verwenden: Einen für die *Zeile* und einen für die *Spalte* des gewünschten Elements.

Das folgende Beispiel zeigt, wie man das Element in der 3. Zeile und der 2. Spalte erhält.

```r
X <- matrix(1:6, ncol = 2)
X[3, 2]
```

```
## [1] 6
```

---
## Matrizen
### Matrixsubsetting

Um dieses Element zu ändern, nutzen wir wieder den Zuweisungsoperator `<-`.

```r
X[3, 2] <- 13
X
```

```
##      [,1] [,2]
## [1,]    1    4
## [2,]    2    5
## [3,]    3   13
```

---
## Matrizen
### Matrixsubsetting

Um ganze Spalten der Matrix zu erhalten, wird der Index für die *Zeile* freigelassen.

```r
X[, 1] # gibt die 1. Spalte zurück
```

```
## [1] 1 2 3
```

Um ganze Zeilen zu erhalten, wird der Index für die *Spalte* freigelassen.

```r
X[2:3, ] # gibt die 2. und 3. Zeile zurück
```

```
##      [,1] [,2]
## [1,]    2    5
## [2,]    3   13
```

---
## Matrizen
### Matrixalgebra --- Übersicht

```r
A <- cbind(c(13, 4, 8), c(2, 8.2, 1))
B <- cbind(c(9, 2.3, -1), c(12, 53, -3))

A * B             # Elementweise Multiplikation

C <- t(A) %*% B # Matrixmultiplikation

t(A)              # Transponieren

diag(C)           # Elemente der Hauptdiagonale

solve(C)          # Invertieren

eigen(C)          # Eigenwerte und Eigenvektoren
```

---
## Matrizen
### Matrixbasierte Funktionen

Wie bei Vektoren gibt es auch eine Reihe von Funktionen für Matrizen.

```r
X <- matrix(1:40, ncol = 4)

colSums(X)   # Spaltensummen

rowSums(X)   # Zeilenensummen

colMeans(X)  # Spaltenmittelwerte

rowMeans(X)  # Zeilenmittelwerte
```

---
## Matritzen
### Übungsaufgaben zu Matritzen

1. Erzeugen Sie mit dem Inputvektor `1:12` und <code>matrix()</code> folgende Matrix `X`.

`$$X =\begin{pmatrix} 
    1 & 2 \\ 
    3 & 4 \\
    5 & 6 \\
    7 & 8 \\
    9 & 10 \\
    11 & 12
  \end{pmatrix}$$`

<ol start="2">
 <li>Nehmen Sie die Matrix aus 1. und vertauschen Sie die Spalten. Das Ergebnis soll an die Variable `Y` übergeben werden.</li>
 <li>Berechnen Sie `$XY^{T}$`.</li>
</ol>

---
## Matritzen
### Übungsaufgaben zu Matritzen

<ol start="4">
 <li>Erzeugen Sie eine $2 \times 2$ Matrix aus der 2. und 5. Zeile der Matrix `X`.</li>
 <li>Erzeugen Sie die Matrix `X` mit $X <- \text{matrix}(8:-7, \text{nrow} = 4)$.</li>
 <ul>
 <li>Ersetzen Sie die Elemente auf der Hauptdiagonalen durch `NA`s.</li>
 <li>Ersetzen Sie jetzt alle `NA`s in der Matrix mit dem Wert $1$. Nutzen Sie dazu die Funktion `is.na()`.</li>
 </ul>
</ol>